AmigActive 21

home *** CD-ROM | disk | FTP | other *** search

/ AmigActive 21 / AACD 21.iso / AACD / Programming / CVS / doc / cvsclient.info-1 < prev next >

Wrap

Text File | 2001-04-27 | 24.4 KB | 530 lines

This is cvsclient.info, produced by makeinfo version 4.0 from cvsclient.texi. INFO-DIR-SECTION Programming START-INFO-DIR-ENTRY * cvsclient: (cvsclient). The CVS client/server protocol. END-INFO-DIR-ENTRY File: cvsclient.info, Node: Top, Next: Introduction, Up: (dir) CVS Client/Server ***************** This document describes the client/server protocol used by CVS. It does not describe how to use or administer client/server CVS; see the regular CVS manual for that. This is version 1.11.1p1 of the protocol specification--*Note Introduction::, for more on what this version number means. * Menu: * Introduction:: What is CVS and what is the client/server protocol for? * Goals:: Basic design decisions, requirements, scope, etc. * Connection and Authentication:: Various ways to connect to the server * Password scrambling:: Scrambling used by pserver * Protocol:: Complete description of the protocol * Protocol Notes:: Possible enhancements, limitations, etc. of the protocol File: cvsclient.info, Node: Introduction, Next: Goals, Prev: Top, Up: Top Introduction ************ CVS is a version control system (with some additional configuration management functionality). It maintains a central "repository" which stores files (often source code), including past versions, information about who modified them and when, and so on. People who wish to look at or modify those files, known as "developers", use CVS to "check out" a "working directory" from the repository, to "check in" new versions of files to the repository, and other operations such as viewing the modification history of a file. If developers are connected to the repository by a network, particularly a slow or flaky one, the most efficient way to use the network is with the CVS-specific protocol described in this document. Developers, using the machine on which they store their working directory, run the CVS "client" program. To perform operations which cannot be done locally, it connects to the CVS "server" program, which maintains the repository. For more information on how to connect see *Note Connection and Authentication::. This document describes the CVS protocol. Unfortunately, it does not yet completely document one aspect of the protocol--the detailed operation of each CVS command and option--and one must look at the CVS user documentation, `cvs.texinfo', for that information. The protocol is non-proprietary (anyone who wants to is encouraged to implement it) and an implementation, known as CVS, is available under the GNU Public License. The CVS distribution, containing this implementation, `cvs.texinfo', and a copy (possibly more or less up to date than what you are reading now) of this document, `cvsclient.texi', can be found at the usual GNU FTP sites, with a filename such as `cvs-VERSION.tar.gz'. This is version 1.11.1p1 of the protocol specification. This version number is intended only to aid in distinguishing different versions of this specification. Although the specification is currently maintained in conjunction with the CVS implementation, and carries the same version number, it also intends to document what is involved with interoperating with other implementations (such as other versions of CVS); see *Note Requirements::. This version number should not be used by clients or servers to determine what variant of the protocol to speak; they should instead use the `valid-requests' and `Valid-responses' mechanism (*note Protocol::), which is more flexible. File: cvsclient.info, Node: Goals, Next: Connection and Authentication, Prev: Introduction, Up: Top Goals ***** * Do not assume any access to the repository other than via this protocol. It does not depend on NFS, rdist, etc. * Providing a reliable transport is outside this protocol. The protocol expects a reliable transport that is transparent (that is, there is no translation of characters, including characters such as such as linefeeds or carriage returns), and can transmit all 256 octets (for example for proper handling of binary files, compression, and encryption). The encoding of characters specified by the protocol (the names of requests and so on) is the invariant ISO 646 character set (a subset of most popular character sets including ASCII and others). For more details on running the protocol over the TCP reliable transport, see *Note Connection and Authentication::. * Security and authentication are handled outside this protocol (but see below about `cvs kserver' and `cvs pserver'). * The protocol makes it possible for updates to be atomic with respect to checkins; that is if someone commits changes to several files in one cvs command, then an update by someone else would either get all the changes, or none of them. The current CVS server can't do this, but that isn't the protocol's fault. * The protocol is, with a few exceptions, transaction-based. That is, the client sends all its requests (without waiting for server responses), and then waits for the server to send back all responses (without waiting for further client requests). This has the advantage of minimizing network turnarounds and the disadvantage of sometimes transferring more data than would be necessary if there were a richer interaction. Another, more subtle, advantage is that there is no need for the protocol to provide locking for features such as making checkins atomic with respect to updates. Any such locking can be handled entirely by the server. A good server implementation (such as the current CVS server) will make sure that it does not have any such locks in place whenever it is waiting for communication with the client; this prevents one client on a slow or flaky network from interfering with the work of others. * It is a general design goal to provide only one way to do a given operation (where possible). For example, implementations have no choice about whether to terminate lines with linefeeds or some other character(s), and request and response names are case-sensitive. This is to enhance interoperability. If a protocol allows more than one way to do something, it is all too easy for some implementations to support only some of them (perhaps accidentally). File: cvsclient.info, Node: Connection and Authentication, Next: Password scrambling, Prev: Goals, Up: Top How to Connect to and Authenticate Oneself to the CVS server ************************************************************ Connection and authentication occurs before the CVS protocol itself is started. There are several ways to connect. server If the client has a way to execute commands on the server, and provide input to the commands and output from them, then it can connect that way. This could be the usual rsh (port 514) protocol, Kerberos rsh, SSH, or any similar mechanism. The client may allow the user to specify the name of the server program; the default is `cvs'. It is invoked with one argument, `server'. Once it invokes the server, the client proceeds to start the cvs protocol. kserver The kerberized server listens on a port (in the current implementation, by having inetd call "cvs kserver") which defaults to 1999. The client connects, sends the usual kerberos authentication information, and then starts the cvs protocol. Note: port 1999 is officially registered for another use, and in any event one cannot register more than one port for CVS, so GSS-API (see below) is recommended instead of kserver as a way to support kerberos. pserver The name "pserver" is somewhat confusing. It refers to both a generic framework which allows the CVS protocol to support several authentication mechanisms, and a name for a specific mechanism which transfers a username and a cleartext password. Servers need not support all mechanisms, and in fact servers will typically want to support only those mechanisms which meet the relevant security needs. The pserver server listens on a port (in the current implementation, by having inetd call "cvs pserver") which defaults to 2401 (this port is officially registered). The client connects, and sends the following: * the string `BEGIN AUTH REQUEST', a linefeed, * the cvs root, a linefeed, * the username, a linefeed, * the password trivially encoded (see *Note Password scrambling::), a linefeed, * the string `END AUTH REQUEST', and a linefeed. The client must send the identical string for cvs root both here and later in the `Root' request of the cvs protocol itself. Servers are encouraged to enforce this restriction. The possible server responses (each of which is followed by a linefeed) are the following. Note that although there is a small similarity between this authentication protocol and the cvs protocol, they are separate. `I LOVE YOU' The authentication is successful. The client proceeds with the cvs protocol itself. `I HATE YOU' The authentication fails. After sending this response, the server may close the connection. It is up to the server to decide whether to give this response, which is generic, or a more specific response using `E' and/or `error'. `E TEXT' Provide a message for the user. After this reponse, the authentication protocol continues with another response. Typically the server will provide a series of `E' responses followed by `error'. Compatibility note: CVS 1.9.10 and older clients will print `unrecognized auth response' and TEXT, and then exit, upon receiving this response. `error CODE TEXT' The authentication fails. After sending this response, the server may close the connection. The CODE is a code describing why it failed, intended for computer consumption. The only code currently defined is `0' which is nonspecific, but clients must silently treat any unrecognized codes as nonspecific. The TEXT should be supplied to the user. Compatibility note: CVS 1.9.10 and older clients will print `unrecognized auth response' and TEXT, and then exit, upon receiving this response. Note that TEXT for this response, or the TEXT in an `E' response, is not designed for machine parsing. More vigorous use of CODE, or future extensions, will be needed to prove a cleaner machine-parseable indication of what the error was. If the client wishes to merely authenticate without starting the cvs protocol, the procedure is the same, except BEGIN AUTH REQUEST is replaced with BEGIN VERIFICATION REQUEST, END AUTH REQUEST is replaced with END VERIFICATION REQUEST, and upon receipt of I LOVE YOU the connection is closed rather than continuing. Another mechanism is GSSAPI authentication. GSSAPI is a generic interface to security services such as kerberos. GSSAPI is specified in RFC2078 (GSSAPI version 2) and RFC1508 (GSSAPI version 1); we are not aware of differences between the two which affect the protocol in incompatible ways, so we make no attempt to specify one version or the other. The procedure here is to start with `BEGIN GSSAPI REQUEST'. GSSAPI authentication information is then exchanged between the client and the server. Each packet of information consists of a two byte big endian length, followed by that many bytes of data. After the GSSAPI authentication is complete, the server continues with the responses described above (`I LOVE YOU', etc.). future possibilities There are a nearly unlimited number of ways to connect and authenticate. One might want to allow access based on IP address (similar to the usual rsh protocol but with different/no restrictions on ports < 1024), to adopt mechanisms such as Pluggable Authentication Modules (PAM), to allow users to run their own servers under their own usernames without root access, or any number of other possibilities. The way to add future mechanisms, for the most part, should be to continue to use port 2401, but to use different strings in place of `BEGIN AUTH REQUEST'. File: cvsclient.info, Node: Password scrambling, Next: Protocol, Prev: Connection and Authentication, Up: Top Password scrambling algorithm ***************************** The pserver authentication protocol, as described in *Note Connection and Authentication::, trivially encodes the passwords. This is only to prevent inadvertent compromise; it provides no protection against even a relatively unsophisticated attacker. For comparison, HTTP Basic Authentication (as described in RFC2068) uses BASE64 for a similar purpose. CVS uses its own algorithm, described here. The scrambled password starts with `A', which serves to identify the scrambling algorithm in use. After that follows a single octet for each character in the password, according to a fixed encoding. The values are shown here, with the encoded values in decimal. Control characters, space, and characters outside the invariant ISO 646 character set are not shown; such characters are not recommended for use in passwords. There is a long discussion of character set issues in *Note Protocol Notes::. 0 111 P 125 p 58 ! 120 1 52 A 57 Q 55 a 121 q 113 " 53 2 75 B 83 R 54 b 117 r 32 3 119 C 43 S 66 c 104 s 90 4 49 D 46 T 124 d 101 t 44 % 109 5 34 E 102 U 126 e 100 u 98 & 72 6 82 F 40 V 59 f 69 v 60 ' 108 7 81 G 89 W 47 g 73 w 51 ( 70 8 95 H 38 X 92 h 99 x 33 ) 64 9 65 I 103 Y 71 i 63 y 97 * 76 : 112 J 45 Z 115 j 94 z 62 + 67 ; 86 K 50 k 93 , 116 < 118 L 42 l 39 - 74 = 110 M 123 m 37 . 68 > 122 N 91 n 61 / 87 ? 105 O 35 _ 56 o 48 File: cvsclient.info, Node: Protocol, Next: Protocol Notes, Prev: Password scrambling, Up: Top The CVS client/server protocol ****************************** In the following, `\n' refers to a linefeed and `\t' refers to a horizontal tab; "requests" are what the client sends and "responses" are what the server sends. In general, the connection is governed by the client--the server does not send responses without first receiving requests to do so; see *Note Response intro:: for more details of this convention. It is typical, early in the connection, for the client to transmit a `Valid-responses' request, containing all the responses it supports, followed by a `valid-requests' request, which elicits from the server a `Valid-requests' response containing all the requests it understands. In this way, the client and server each find out what the other supports before exchanging large amounts of data (such as file contents). * Menu: General protocol conventions: * Entries Lines:: Transmitting RCS data * File Modes:: Read, write, execute, and possibly more... * Filenames:: Conventions regarding filenames * File transmissions:: How file contents are transmitted * Strings:: Strings in various requests and responses * Dates:: Times and dates The protocol itself: * Request intro:: General conventions relating to requests * Requests:: List of requests * Response intro:: General conventions relating to responses * Response pathnames:: The "pathname" in responses * Responses:: List of responses * Text tags:: More details about the MT response An example session, and some further observations: * Example:: A conversation between client and server * Requirements:: Things not to omit from an implementation * Obsolete:: Former protocol features File: cvsclient.info, Node: Entries Lines, Next: File Modes, Up: Protocol Entries Lines ============= Entries lines are transmitted as: / NAME / VERSION / CONFLICT / OPTIONS / TAG_OR_DATE TAG_OR_DATE is either `T' TAG or `D' DATE or empty. If it is followed by a slash, anything after the slash shall be silently ignored. VERSION can be empty, or start with `0' or `-', for no user file, new user file, or user file to be removed, respectively. CONFLICT, if it starts with `+', indicates that the file had conflicts in it. The rest of CONFLICT is `=' if the timestamp matches the file, or anything else if it doesn't. If CONFLICT does not start with a `+', it is silently ignored. OPTIONS signifies the keyword expansion options (for example `-ko'). In an `Entry' request, this indicates the options that were specified with the file from the previous file updating response (*note Response intro::, for a list of file updating responses); if the client is specifying the `-k' or `-A' option to `update', then it is the server which figures out what overrides what. File: cvsclient.info, Node: File Modes, Next: Filenames, Prev: Entries Lines, Up: Protocol File Modes ========== A mode is any number of repetitions of MODE-TYPE = DATA separated by `,'. MODE-TYPE is an identifier composed of alphanumeric characters. Currently specified: `u' for user, `g' for group, `o' for other (see below for discussion of whether these have their POSIX meaning or are more loose). Unrecognized values of MODE-TYPE are silently ignored. DATA consists of any data not containing `,', `\0' or `\n'. For `u', `g', and `o' mode types, data consists of alphanumeric characters, where `r' means read, `w' means write, `x' means execute, and unrecognized letters are silently ignored. The two most obvious ways in which the mode matters are: (1) is it writeable? This is used by the developer communication features, and is implemented even on OS/2 (and could be implemented on DOS), whose notion of mode is limited to a readonly bit. (2) is it executable? Unix CVS users need CVS to store this setting (for shell scripts and the like). The current CVS implementation on unix does a little bit more than just maintain these two settings, but it doesn't really have a nice general facility to store or version control the mode, even on unix, much less across operating systems with diverse protection features. So all the ins and outs of what the mode means across operating systems haven't really been worked out (e.g. should the VMS port use ACLs to get POSIX semantics for groups?). File: cvsclient.info, Node: Filenames, Next: File transmissions, Prev: File Modes, Up: Protocol Conventions regarding transmission of file names ================================================ In most contexts, `/' is used to separate directory and file names in filenames, and any use of other conventions (for example, that the user might type on the command line) is converted to that form. The only exceptions might be a few cases in which the server provides a magic cookie which the client then repeats verbatim, but as the server has not yet been ported beyond unix, the two rules provide the same answer (and what to do if future server ports are operating on a repository like e:/foo or CVS_ROOT:[FOO.BAR] has not been carefully thought out). Characters outside the invariant ISO 646 character set should be avoided in filenames. This restriction may need to be relaxed to allow for characters such as `[' and `]' (see above about non-unix servers); this has not been carefully considered (and currently implementations probably use whatever character sets that the operating systems they are running on allow, and/or that users specify). Of course the most portable practice is to restrict oneself further, to the POSIX portable filename character set as specified in POSIX.1. File: cvsclient.info, Node: File transmissions, Next: Strings, Prev: Filenames, Up: Protocol File transmissions ================== File contents (noted below as FILE TRANSMISSION) can be sent in one of two forms. The simpler form is a number of bytes, followed by a linefeed, followed by the specified number of bytes of file contents. These are the entire contents of the specified file. Second, if both client and server support `gzip-file-contents', a `z' may precede the length, and the `file contents' sent are actually compressed with `gzip' (RFC1952/1951) compression. The length specified is that of the compressed version of the file. In neither case are the file content followed by any additional data. The transmission of a file will end with a linefeed iff that file (or its compressed form) ends with a linefeed. The encoding of file contents depends on the value for the `-k' option. If the file is binary (as specified by the `-kb' option in the appropriate place), then it is just a certain number of octets, and the protocol contributes nothing towards determining the encoding (using the file name is one widespread, if not universally popular, mechanism). If the file is text (not binary), then the file is sent as a series of lines, separated by linefeeds. If the keyword expansion is set to something other than `-ko', then it is expected that the file conform to the RCS expectations regarding keyword expansion--in particular, that it is in a character set such as ASCII in which 0x24 is a dollar sign (`$'). File: cvsclient.info, Node: Strings, Next: Dates, Prev: File transmissions, Up: Protocol Strings ======= In various contexts, for example the `Argument' request and the `M' response, one transmits what is essentially an arbitrary string. Often this will have been supplied by the user (for example, the `-m' option to the `ci' request). The protocol has no mechanism to specify the character set of such strings; it would be fairly safe to stick to the invariant ISO 646 character set but the existing practice is probably to just transmit whatever the user specifies, and hope that everyone involved agrees which character set is in use, or sticks to a common subset. File: cvsclient.info, Node: Dates, Next: Request intro, Prev: Strings, Up: Protocol Dates ===== The protocol contains times and dates in various places. For the `-D' option to the `annotate', `co', `diff', `export', `history', `rannotate', `rdiff', `rtag', `tag', and `update' requests, the server should support two formats: 26 May 1997 13:01:40 -0000 ; RFC 822 as modified by RFC 1123 5/26/1997 13:01:40 GMT ; traditional The former format is preferred; the latter however is sent by the CVS command line client (versions 1.5 through at least 1.9). For the `-d' option to the `log' and `rlog' requests, servers should at least support RFC 822/1123 format. Clients are encouraged to use this format too (the command line CVS client, version 1.10 and older, just passed along the date format specified by the user, however). The `Mod-time' response and `Checkin-time' request use RFC 822/1123 format (see the descriptions of that response and request for details). For `Notify', see the description of that request. File: cvsclient.info, Node: Request intro, Next: Requests, Prev: Dates, Up: Protocol Request intro ============= By convention, requests which begin with a capital letter do not elicit a response from the server, while all others do - save one. The exception is `gzip-file-contents'. Unrecognized requests will always elicit a response from the server, even if that request begins with a capital letter. The term "command" means a request which expects a response (except `valid-requests'). The general model is that the client transmits a great number of requests, but nothing happens until the very end when the client transmits a command. Although the intention is that transmitting several commands in one connection should be legal, existing servers probably have some bugs with some combinations of more than one command, and so clients may find it necessary to make several connections in some cases. This should be thought of as a workaround rather than a desired attribute of the protocol.